home *** CD-ROM | disk | FTP | other *** search
/ Macwelt 1 / Macwelt DVD 1.toast / Web-Publishing / HTML-Editoren / Alpha ƒ / Tcl / Modes / Matlab mode / matlabComm.tcl next >
Encoding:
Text File  |  2000-05-10  |  11.0 KB  |  413 lines
  1. ################################################################################
  2. #
  3. # matlabComm.tcl, part of the matlab mode package
  4. # 
  5. # Communicate with MATLAB
  6. # 
  7. ################################################################################
  8.  
  9. proc matlabComm.tcl {} {}
  10.  
  11. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
  12. #
  13. # ◊◊◊◊ Core interaction with MATLAB ◊◊◊◊ #
  14. #
  15. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-
  16.  
  17. #################################################################################
  18. # Launch MATLAB in background if not already running
  19. ################################################################################
  20.  
  21. proc matlabLaunch {} {
  22.     global matlabSig
  23.     set name [app::launchBack $matlabSig]
  24.  
  25. #     global matlabPath
  26. #     catch {checkRunning MATLAB MATL matlabPath} name
  27.  
  28.     return $name
  29. }
  30.  
  31.  
  32. #################################################################################
  33. # Tell MATLAB to do a script.  
  34. # Echo script and script results in command window if desired.
  35. #   showResults = 0 show nothing
  36. #                 1 echo command in command window and show results when done
  37. #                 2 do not echo command but do show results when done
  38. #   forceWait = 0 que command 
  39. #               1 wait for result and return it
  40. #               
  41. #  If sending a list of scripts all argins must be present and of same length 
  42. #  except forceWait which can only be a single 0
  43. ################################################################################
  44.  
  45. proc matlabDoScript {scriptName {showResults 1} {forceWait 0} {replyHandler MATL::ReplyHandler}} {
  46.     global MATLmodeVars MATLeventQue matlabBusy
  47.     
  48.     matlabLaunch
  49.     
  50.     if {$forceWait} {
  51.         message "Waiting for result from MATLAB"
  52.         set res [dosc -c {'MATL'} -s $scriptName]
  53.         message "Got result from MATLAB"
  54.         if {$showResults} {
  55.             matlabCmdWindow
  56.             insertText "${scriptName}\n"
  57.             matlabResults $res
  58.         }
  59.         return $res
  60.     }
  61.     
  62.     if {$matlabBusy && ! $MATLmodeVars(queEventsQuietly)} {
  63.         if {[askyesno "Matlab is busy, should I queue your request:\r\"$scriptName\""] == "no"} {
  64.             return
  65.         }
  66.     }
  67.     
  68.     if {[llength $showResults] > 1} {
  69.         for {set i 0} {$i < [llength $scriptName]} {incr i} {
  70.             lappend MATLeventQue "{[lindex $scriptName $i]} [lindex $showResults $i] [lindex $replyHandler $i]"
  71.         }
  72.     } else {
  73.         lappend MATLeventQue "{$scriptName} $showResults $replyHandler"
  74.     }
  75.     
  76.     if {! $matlabBusy} {
  77.         MATL::queNextEvent
  78.     }
  79. }
  80.  
  81. ################################################################################
  82. # Switch to Matlab
  83. ################################################################################
  84.  
  85. proc matlab {} {
  86.     global matlabSig
  87.     app::launchFore $matlabSig
  88. }
  89.  
  90. ################################################################################
  91. # Check if Matlab is running
  92. ################################################################################
  93.  
  94. proc isMatlabRunning {} {
  95.     global matlabSig
  96.     
  97.     return [app::isRunning $matlabSig]
  98.  
  99. #     foreach proc [processes] {
  100. #         if {[lsearch -exact $matlabSig [lindex $proc 1]] >= 0} {return 1}
  101. #     }
  102. #     return 0
  103.  
  104. }
  105.  
  106. ################################################################################ 
  107. # Matlab Save Hook to clear the current function from MATLAB's memory.  
  108. # This is useful for editing callback functions that don't get checked 
  109. # for modifiction.
  110. ################################################################################
  111.  
  112. proc MATL::saveHook {name} {
  113.     global MATLmodeVars
  114.  
  115.     #
  116.     # Check if the user wants functions cleared on save and sure MATLAB 
  117.     # is running.  We don't need to clear if it is not!
  118.     #
  119.     if {[isMatlabRunning] && $MATLmodeVars(clearOnSave)} then {
  120.         #
  121.         # Now clear the function
  122.         #
  123.         set procName [file rootname [file tail $name]]
  124. #         set scriptName "clear $procName"
  125.         set scriptName "clear functions"
  126.         matlabDoScript $scriptName 0
  127.         message $scriptName
  128.         return
  129.     }
  130. }
  131.  
  132.  
  133. ################################################################################
  134. #  Ask MATLAB for the location of a file.
  135. ################################################################################
  136.  
  137. proc matlabWhichFile {name} {
  138.     global matlabBusy
  139.     
  140.     if {$matlabBusy} {
  141.         alertnote "Matlab is busy, try again later."
  142.         return ""
  143.     }
  144.     
  145.     set mFile [string trim [matlabDoScript "which $name" 0 1]]
  146.     
  147.     # if it is a mex-file get the associated m-file
  148.     if {[string compare [file extension $mFile] ".mex"] == 0} {
  149.         set fRoot [file rootname $mFile]
  150.         set mExt {.m}
  151.         set mFile $fRoot$mExt
  152.     }
  153.     
  154.     return $mFile
  155. }
  156.  
  157. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
  158. #
  159. # ◊◊◊◊ Send stuff to MATLAB ◊◊◊◊ #
  160. #
  161. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-
  162.  
  163. ################################################################################
  164. #  Edit current window in MATLAB
  165. ################################################################################
  166.  
  167. proc editInMatlab {} {
  168.     
  169.     if {[winDirty]} {
  170.         if {[askyesno "Save '[lindex [winNames] 0]'?"] == "yes"} {
  171.             save
  172.         } else {
  173.             return
  174.         }
  175.     }
  176.     
  177.     set matName [matlabLaunch]
  178.     
  179.     if {[catch {sendOpenEvent -n $matName [lindex [winNames -f] 0]}] } {
  180.         beep 
  181.     } else {
  182.         switchTo $matName
  183.         killWindow
  184.     }
  185. }
  186.  
  187.  
  188. ################################################################################
  189. #  Debug current window in MATLAB
  190. ################################################################################
  191.  
  192. proc debugInMatlab {} {
  193.     
  194.     if {[winDirty]} {
  195.         if {[askyesno "Save '[lindex [winNames] 0]'?"] == "yes"} {
  196.             save
  197.         } else {
  198.             return
  199.         }
  200.     }
  201.     
  202.     set mFile [lindex [winNames -f] 0]
  203.     set procName [file rootname [file tail $mFile]]
  204.     
  205.     set scriptName "mactools mdebug $procName"
  206.     matlabDoScript $scriptName 0
  207.     switchTo [matlabLaunch]
  208. }
  209.  
  210.  
  211. ################################################################################
  212. #  Save current window and execute it in MATLAB
  213. ################################################################################
  214.  
  215. proc matlabSaveAndExecute {} {
  216.     global MATLmodeVars
  217.     
  218.     # Temporarily turn off clearOnSave so we can send all events at once
  219.     if {[winDirty]} {
  220.         set oldClearOnSave $MATLmodeVars(clearOnSave)
  221.         set MATLmodeVars(clearOnSave) 0
  222.         save
  223.         set MATLmodeVars(clearOnSave) $oldClearOnSave
  224.     }
  225.     
  226.     # Get the path of the current window and it's name
  227.     set mFile [lindex [winNames -f] 0]
  228.     regsub -all -- {'} [file dirname $mFile] {''} mFilePath
  229.     set procName [file rootname [file tail $mFile]]
  230.     
  231.     # Begin building event list
  232.     # Change current working directory to window's and do the script
  233.     set theScripts [list "cd '$mFilePath'" "$procName"]
  234.     set handlers [list MATL::NullReplyHandler MATL::ReplyHandler]
  235.     set showResults [list 0 1]
  236.     
  237.     # Now add the clearOnSave if necessary to event list
  238.     if {$MATLmodeVars(clearOnSave) && [isMatlabRunning]} then {
  239. #         set scriptName "clear $procName"
  240.         set scriptName "clear functions"
  241.         set theScripts [concat [list $scriptName] $theScripts]
  242.         set handlers [concat [list MATL::NullReplyHandler] $handlers]
  243.         set showResults [concat [list 0] $showResults]
  244.     }
  245.     
  246.     # Do the script
  247.     matlabDoScript  $theScripts $showResults 0 $handlers
  248. }
  249.  
  250.  
  251. ################################################################################
  252. #  Send line to MATLAB
  253. ################################################################################
  254.  
  255. proc matlabDoLine {} {
  256.     beginningOfLine
  257.     set bol [getPos]
  258.     endOfLine
  259.     set eol [getPos]
  260.     set scriptName [getText $bol $eol]
  261.     matlabDoScript $scriptName
  262. }
  263.  
  264.  
  265. ################################################################################
  266. #  Send line or selection to MATLAB
  267. ################################################################################
  268.  
  269. proc matlabDoSelectionOrLine {} {
  270.     if {[pos::compare [getPos] == [selEnd]]} {
  271.     set bol [lineStart [getPos]]
  272.     set eol [pos::math [nextLineStart [getPos]] - 2]
  273.     set scriptName [string trim [getText $bol $eol]]
  274.     } else {
  275.     set scriptName [string trim [getSelect]]
  276.     }
  277.     
  278.     matlabDoScript $scriptName
  279.     return $scriptName
  280. }
  281.  
  282.  
  283. ################################################################################
  284. #  Open selected .m file
  285. ################################################################################
  286.  
  287. proc matlabOpenSelection {} {
  288.     MATL::editMfile [getSelect]
  289. }
  290.  
  291. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
  292. #
  293. # ◊◊◊◊ Reply handlers ◊◊◊◊ #
  294. #
  295. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-
  296.  
  297.  
  298. ################################################################################
  299. #  Handle the reply from MATLAB
  300. ################################################################################
  301.  
  302. proc MATL::ReplyHandler {res} {
  303.     
  304.     if {[regexp -- {(“)([^”]*)} $res dum1 dum2 res1]} {
  305.         matlabResults $res1
  306.     } else {
  307.         alertnote $res1
  308.     }
  309.     
  310.     MATL::queNextEvent
  311.     
  312.     return 1
  313. }
  314.  
  315.  
  316. ################################################################################
  317. #  Handle the reply from MATLAB by doing nothing special
  318. ################################################################################
  319.  
  320. proc MATL::NullReplyHandler {res} {
  321.     MATL::queNextEvent
  322.     return 1
  323. }
  324.  
  325.  
  326.  
  327. ################################################################################
  328. #  Handle the reply from MATLAB for a definition
  329. ################################################################################
  330.  
  331. proc MATL::DocReplyHandler {res} {
  332.     global MATLcurrentScript
  333.     
  334.     if {[regexp -- {(“)([^”]*)} $res dum1 dum2 res1]} {
  335.         if {[regexp -- {not found.} [string range $res 0 100]]} {
  336.             alertnote $res1
  337.         } else {
  338.             matlabShowDefinition $MATLcurrentScript $res1
  339.         }
  340.     } else {
  341.         alertnote $res
  342.     }
  343.     
  344.     MATL::queNextEvent
  345.     
  346.     return 1
  347. }
  348.         
  349. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
  350. #
  351. # ◊◊◊◊ Event que ◊◊◊◊ #
  352. #
  353. #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-
  354.  
  355. ################################################################################
  356. #  Move the next event up in the que
  357. ################################################################################
  358.  
  359. proc MATL::queNextEvent {} {
  360.     global MATLeventQue matlabBusy
  361.     
  362.     set matlabBusy 0
  363.     
  364.     if {[llength $MATLeventQue] > 0} {
  365.         set nextEvent [lindex $MATLeventQue 0]
  366.         set MATLeventQue [lrange $MATLeventQue 1 end]
  367.         eval "MATL::DoEvent $nextEvent"
  368.     }
  369. }
  370.  
  371.  
  372. ################################################################################
  373. #  Do the current event
  374. ################################################################################
  375.  
  376. proc MATL::DoEvent {scriptName showResults replyHandler} {
  377.     global matlabBusy MATLcurrentScript
  378.     
  379.     switch -- $showResults {
  380.         0 {
  381.             currentReplyHandler MATL::NullReplyHandler
  382.             dosc -q -c {'MATL'} -s $scriptName
  383.         }
  384.         1 {
  385.             matlabCmdWindow
  386.             insertText "${scriptName}\n"
  387.             set MATLcurrentScript $scriptName
  388.             currentReplyHandler $replyHandler
  389.             dosc -q -c {'MATL'} -s $scriptName
  390.         }
  391.         2 {
  392.             set MATLcurrentScript $scriptName
  393.             currentReplyHandler $replyHandler
  394.             dosc -q -c {'MATL'} -s $scriptName
  395.         }
  396.     }
  397.     set matlabBusy 1
  398. }
  399.  
  400. ################################################################################
  401. #  Manually clear the event que
  402. ################################################################################
  403.  
  404. proc MATL::clearEventQue {} {
  405.     global MATLeventQue matlabBusy
  406.     
  407.     set matlabBusy 0
  408.     set MATLeventQue ""
  409.     
  410. }
  411.  
  412.  
  413.